/**
 * DeepSeek-R1 AI模型扩展库
 * 
 * 这个文件定义了DeepSeek-R1 AI模型扩展库中的积木块外观和功能
 */

//% color="#0066CC" iconWidth=50 iconHeight=40
// 设置积木块的颜色和图标大小
namespace deepseek_ai {
  
  // 全局变量，用于保存模型实例
  let initialized = false;
  
  /**
   * 初始化DeepSeek-R1 AI模型
   */
  //% block="连接AI助手 密钥[API_KEY]" blockType="command"
  //% API_KEY.shadow="string" API_KEY.defl="sk-303c46fb3c0d44919099e23233e964b5"
  export function initDeepSeek(parameter: any, block: any) {
    // 获取参数
    const apiKey = parameter.API_KEY.code;
    
    // 添加必要的导入语句
    Generator.addImport('import os');
    Generator.addImport('import json');
    Generator.addImport('import sys');
    Generator.addImport('import importlib.util');
    
    // 定义 DeepSeekR1 类，这样不需要导入文件
    Generator.addCode(`
# DeepSeek-R1 模型辅助类
class DeepSeekR1:
    def __init__(self, api_key=None):
        """
        初始化DeepSeek-R1助手
        
        参数:
            api_key (str, 可选): DeepSeek API密钥，使用API时需要
        """
        self.api_key = api_key
        self.api_url = "https://api.deepseek.com/v1/chat/completions"
        self.system_role = None
        self.model_type = "deepseek-chat"  # 默认使用V3模型
        
        # 验证参数合法性
        if not api_key:
            print("警告: 未提供API密钥，部分功能可能无法使用")
    
    def generate_text(self, prompt, max_tokens=500, temperature=0.7):
        """生成文本响应"""
        if not prompt:
            return "错误: 提示文本不能为空"
            
        return self._generate_api(prompt, max_tokens, temperature)
    
    def _generate_api(self, prompt, max_tokens, temperature):
        """使用API生成文本"""
        import requests
        
        if not self.api_key:
            return "错误: 使用API需要提供API密钥"
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        messages = []
        
        # 添加系统角色消息
        if self.system_role:
            messages.append({"role": "system", "content": self.system_role})
            
        # 添加用户消息
        messages.append({"role": "user", "content": prompt})
        
        data = {
            "model": self.model_type,
            "messages": messages,
            "max_tokens": max_tokens
        }
        
        # 对于V3模型，添加temperature参数
        if self.model_type == "deepseek-chat":
            data["temperature"] = temperature
            
        try:
            response = requests.post(self.api_url, headers=headers, json=data)
            if response.status_code == 200:
                result = response.json()
                if self.model_type == "deepseek-reasoner":
                    # 处理推理模型的响应，它会包含reasoning_content和content
                    reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
                    content = result["choices"][0]["message"]["content"]
                    # 返回两部分内容
                    return f"""【思考过程】:
{reasoning_content}

【最终回答】:
{content}"""
                else:
                    # 普通V3模型
                    return result["choices"][0]["message"]["content"]
            else:
                return f"API请求错误: {response.status_code}, {response.text}"
        except Exception as e:
            return f"API请求异常: {str(e)}"
    
    def summarize(self, text, max_tokens=200):
        """文本摘要功能"""
        if not text:
            return "错误: 要摘要的文本不能为空"
            
        prompt = f"请对以下文本进行总结，保持简洁明了：\\n\\n{text}"
        return self.generate_text(prompt, max_tokens, temperature=0.3)
    
    def translate(self, text, target_lang="中文"):
        """文本翻译功能"""
        if not text:
            return "错误: 要翻译的文本不能为空"
            
        prompt = f"请将以下文本翻译成{target_lang}：\\n\\n{text}"
        return self.generate_text(prompt, max_tokens=len(text)*2, temperature=0.3)
    
    def answer_question(self, question, context=None):
        """回答问题功能"""
        if not question:
            return "错误: 问题不能为空"
            
        if context:
            prompt = f"基于以下信息回答问题:\\n\\n背景信息: {context}\\n\\n问题: {question}"
        else:
            prompt = question
        
        return self.generate_text(prompt, max_tokens=500, temperature=0.7)
    
    def chat(self, messages, max_tokens=500, temperature=0.7):
        """进行多轮对话"""
        import requests
        
        if not messages or not isinstance(messages, list):
            return "错误: 消息必须是一个有效的列表"
            
        if not self.api_key:
            return "错误: 使用API需要提供API密钥"
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        data = {
            "model": self.model_type,
            "messages": messages,
            "max_tokens": max_tokens,
            "temperature": temperature
        }
        
        try:
            response = requests.post(self.api_url, headers=headers, json=data)
            
            if response.status_code == 200:
                return response.json()["choices"][0]["message"]["content"]
            elif response.status_code == 401:
                return "API密钥无效或已过期，请检查API密钥"
            elif response.status_code == 429:
                return "API请求次数超限，请稍后再试"
            else:
                return f"API请求错误: {response.status_code}, {response.text}"
        except Exception as e:
            return f"API请求异常: {str(e)}"

    def set_system_role(self, role):
        """设置系统预设角色"""
        role_descriptions = {
            "全能助手": "你是一位全能型人工智能助手，能够提供各种领域的帮助和解答。你应当非常有耐心、有礼貌，且回答准确、实用。",
            "知识导师": "你是一位拥有广博知识的智能导师，擅长深入解析各类学科知识。你的回答应当有教育意义，有深度，且易于理解。",
            "故事创作家": "你是一位富有想象力的故事创作家，擅长编写各种风格和题材的故事。你的创作应当生动有趣，充满吸引力。",
            "科学专家": "你是一位严谨的科学专家，擅长解释各种科学现象和原理。你的回答应当基于科学事实，清晰准确。",
            "数学老师": "你是一位耐心的数学老师，擅长解释数学概念和解决数学问题。你应当善于分步骤讲解，让复杂的问题变得简单。",
            "编程教练": "你是一位专业的编程教练，擅长教授编程知识和解决编程问题。你的回答应当包含实用的代码示例和详细解释。",
            "翻译专家": "你是一位精通多种语言的翻译专家，能够准确翻译各种语言内容。你的翻译应当忠实原文，同时符合目标语言的表达习惯。",
            "写作顾问": "你是一位专业的写作顾问，擅长帮助改进各类文章和文档。你应当善于提供建设性的意见，帮助提升文章质量。"
        }
        
        if role in role_descriptions:
            self.system_role = role_descriptions[role]
            print(f"已设置系统角色: {role}")
        else:
            self.system_role = role
            print(f"已设置自定义角色")
            
    def set_custom_role(self, description):
        """设置自定义角色描述"""
        self.system_role = description
        print("已设置自定义角色描述")
        
    def set_model_type(self, model_type):
        """设置模型类型"""
        valid_models = ["deepseek-chat", "deepseek-reasoner"]
        if model_type in valid_models:
            self.model_type = model_type
            print(f"已设置模型类型: {model_type}")
        else:
            print(f"无效的模型类型: {model_type}，将使用默认模型 deepseek-chat")
            self.model_type = "deepseek-chat"
# 初始化DeepSeek-R1模型
try:
    print("正在初始化DeepSeek-R1模型...")
    deepseek_model = DeepSeekR1(
        api_key=${apiKey} if ${apiKey} else "sk-303c46fb3c0d44919099e23233e964b5"
    )
    print("DeepSeek-R1模型初始化完成")
except Exception as e:
    print(f"初始化DeepSeek-R1模型时出错: {str(e)}")
`);
    
    // 设置初始化标志
    initialized = true;
  }

  /**
   * 生成文本
   */
  //% block="AI对话 提示词[PROMPT] 最大字数[MAX_TOKENS] 创意度[TEMPERATURE]" blockType="reporter"
  //% PROMPT.shadow="string" PROMPT.defl="请介绍一下自己"
  //% MAX_TOKENS.shadow="number" MAX_TOKENS.defl=500
  //% TEMPERATURE.shadow="dropdown" TEMPERATURE.options="TEMPERATURE_LIST" TEMPERATURE.defl=0.7
  export function generateText(parameter: any, block: any) {
    // 获取参数
    const prompt = parameter.PROMPT.code;
    const maxTokens = parameter.MAX_TOKENS.code;
    const temperature = parameter.TEMPERATURE.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`deepseek_model.generate_text(${prompt}, max_tokens=${maxTokens}, temperature=${temperature})`);
  }

  /**
   * 文本摘要
   */
  //% block="AI总结 原文[TEXT] 最大字数[MAX_TOKENS]" blockType="reporter"
  //% TEXT.shadow="string" TEXT.defl="这是一段需要总结的长文本"
  //% MAX_TOKENS.shadow="number" MAX_TOKENS.defl=200
  export function summarizeText(parameter: any, block: any) {
    // 获取参数
    const text = parameter.TEXT.code;
    const maxTokens = parameter.MAX_TOKENS.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`deepseek_model.summarize(${text}, max_tokens=${maxTokens})`);
  }

  /**
   * 文本翻译
   */
  //% block="AI翻译 原文[TEXT] 目标语言[LANGUAGE]" blockType="reporter"
  //% TEXT.shadow="string" TEXT.defl="Hello world"
  //% LANGUAGE.shadow="dropdown" LANGUAGE.options="LANGUAGE_LIST" LANGUAGE.defl="中文"
  export function translateText(parameter: any, block: any) {
    // 获取参数
    const text = parameter.TEXT.code;
    const language = parameter.LANGUAGE.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`deepseek_model.translate(${text}, target_lang=${language})`);
  }

  /**
   * 问答功能
   */
  //% block="AI回答 问题[QUESTION] 背景信息[CONTEXT]" blockType="reporter"
  //% QUESTION.shadow="string" QUESTION.defl="什么是人工智能?"
  //% CONTEXT.shadow="string" CONTEXT.defl=""
  export function answerQuestion(parameter: any, block: any) {
    // 获取参数
    const question = parameter.QUESTION.code;
    const context = parameter.CONTEXT.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`deepseek_model.answer_question(${question}, context=${context} if ${context} else None)`);
  }

  /**
   * 保存聊天对话
   */
  //% block="保存对话记录 内容[CHAT] 保存位置[FILE_PATH]" blockType="command"
  //% CHAT.shadow="string" CHAT.defl=""
  //% FILE_PATH.shadow="string" FILE_PATH.defl="chat_history.txt"
  export function saveChatToFile(parameter: any, block: any) {
    // 获取参数
    const chat = parameter.CHAT.code;
    const filePath = parameter.FILE_PATH.code;
    
    // 生成代码
    Generator.addCode(`
# 保存对话到文件
try:
    with open(${filePath}, 'w', encoding='utf-8') as f:
        f.write(${chat})
    print(f"对话已保存到文件: {${filePath}}")
except Exception as e:
    print(f"保存对话到文件时出错: {str(e)}")
`);
  }

  /**
   * 从文件加载对话
   */
  //% block="读取对话记录 文件位置[FILE_PATH]" blockType="reporter"
  //% FILE_PATH.shadow="string" FILE_PATH.defl="chat_history.txt"
  export function loadChatFromFile(parameter: any, block: any) {
    // 获取参数
    const filePath = parameter.FILE_PATH.code;
    
    // 生成代码
    Generator.addCode(`
# 从文件加载对话
try:
    with open(${filePath}, 'r', encoding='utf-8') as f:
        return f.read()
except FileNotFoundError:
    return f"错误: 文件不存在: {${filePath}}"
except Exception as e:
    return f"从文件加载对话时出错: {str(e)}"
`);
  }

  /**
   * 设置系统角色
   */
  //% block="设置系统角色 角色[ROLE]" blockType="command"
  //% ROLE.shadow="dropdown" ROLE.options="SYSTEM_ROLE_LIST" ROLE.defl="全能助手"
  export function setSysRole(parameter: any, block: any) {
    // 获取参数
    const role = parameter.ROLE.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`
# 设置系统角色
try:
    deepseek_model.set_system_role(${role})
    role_value = ${role}
    print(f"已设置AI角色为: {role_value}")
except Exception as e:
    print(f"设置角色时出错: {str(e)}")
`);
  }

  /**
   * 设置自定义角色
   */
  //% block="设置AI角色 自定义角色描述[DESCRIPTION]" blockType="command"
  //% DESCRIPTION.shadow="string" DESCRIPTION.defl="你是一位专业的科学老师，擅长用简单的语言解释复杂的概念"
  export function setCustomRole(parameter: any, block: any) {
    // 获取参数
    const description = parameter.DESCRIPTION.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`
# 设置自定义角色
try:
    deepseek_model.set_custom_role(${description})
    print(f"已设置自定义AI角色")
except Exception as e:
    print(f"设置角色时出错: {str(e)}")
`);
  }

  /**
   * 设置模型类型
   */
  //% block="设置模型类型 模型类型[MODEL_TYPE]" blockType="command"
  //% MODEL_TYPE.shadow="dropdown" MODEL_TYPE.options="MODEL_TYPE_LIST" MODEL_TYPE.defl="deepseek-chat"
  export function setModelType(parameter: any, block: any) {
    // 获取参数
    const modelType = parameter.MODEL_TYPE.code;
    
    // 生成代码
    if (!initialized) {
      Generator.addCode(`"请先连接AI助手"`);
      return;
    }
    
    Generator.addCode(`
# 设置模型类型
try:
    deepseek_model.set_model_type(${modelType})
    model_type_value = ${modelType}
    print(f"已设置模型类型: {model_type_value}")
except Exception as e:
    print(f"设置模型类型时出错: {str(e)}")
`);
  }
}
